/**
 * @file hal_iic.c
 * @author liufeng (liufeng@injoinic.com)
 * @brief hardware iic with LL library.
 * @version 0.1
 * @date 2024-11-14
 *
 * @copyright Copyright (c) 2024  injoinic
 *
 */

#include "hal_iic.h"
#include "main.h"

/* variables ---------------------------------------------------------------- */

I2C_HandleTypeDef i2c1_handle = {
    .Instance = I2C1,
    .dmatx = DMA1,
    .dmatx_stream = LL_DMA_STREAM_1,
    .dmarx = DMA1,
    .dmarx_stream = LL_DMA_STREAM_0
};

/* function ----------------------------------------------------------------- */

/**
 * @brief 等待I2C的寄存器标志位
 * @param[in] I2Cx 硬件I2C
 * @param[in] pf_LL_I2C_CheckFlag LL库检查Flag的函数指针，例如LL_I2C_IsActiveFlag_BUSY
 * @param[in] Status 等待标志位为0或者为1
 * @param[in] Timeout 超时时间，单位为ms
 * @return 0: 未超时
 *         1：等待flag超时
 */
static uint8_t I2C_WaitFlag(
    I2C_TypeDef* I2Cx,
    uint32_t (*pf_LL_I2C_CheckFlag)(I2C_TypeDef*),
    FlagStatus Status,
    uint32_t Timeout
)
{
    uint32_t tmp = pf_LL_I2C_CheckFlag(I2Cx);
    uint32_t timeout = Timeout;
    while ((timeout > 0) && (tmp != Status)) { // 等待标志位
        if (LL_SYSTICK_IsActiveCounterFlag()) {
            timeout--;
            if (timeout == 0)
                return 1; // 等待超时
        }
        tmp = pf_LL_I2C_CheckFlag(I2Cx);
    }
    return 0; // 未超时
}

/**
 * @brief 使用硬件I2C阻塞方式，发送数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] pData 待发送数据的地址
 * @param[in] Size 待发送数据的长度
 * @param[in] Timeout 超时时间
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_transmit(
    I2C_HandleTypeDef* hi2c, uint16_t SlaveAddr, uint8_t* pData, uint16_t Size, uint32_t Timeout
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, Timeout)) // 等待busy位置0
        return 1;
    LL_I2C_GenerateStartCondition(hi2c->Instance);                          // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, Timeout))   // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));                 // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, Timeout)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance); // 清除addr标志位

    for (uint32_t i = 0; i < Size; i++) {  // 逐字节发送
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout)) // 等待TxE位置1
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, *(pData + i));                    // 发送数据
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BTF, 1, Timeout)) // 等待BTF位置1
        return 1;
    LL_I2C_GenerateStopCondition(hi2c->Instance);                          // 生成stop信号

    return 0;
}

/**
 * @brief 使用硬件I2C阻塞方式，接收数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] pData 接收数据的缓冲区地址
 * @param[in] Size 待接收的数据长度
 * @param[in] Timeout 超时时间
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_receive(
    I2C_HandleTypeDef* hi2c, uint16_t SlaveAddr, uint8_t* pData, uint16_t Size, uint32_t Timeout
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, Timeout)) // 等待busy位置0
        return 1;

    LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_ACK);               // 置位ACK
    LL_I2C_GenerateStartCondition(hi2c->Instance);                        // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, Timeout)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1) | 1);             // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, Timeout)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance); // 清除addr标志位

    for (uint32_t i = 0; i < Size; i++) {  // 读取数据
        if (i == Size - 1) {               // 接收最后一个数据前，发送NACK和stop
            LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_NACK); // 发送NACK
            LL_I2C_GenerateStopCondition(hi2c->Instance);            // 生成stop信号
        }
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_RXNE, 1, Timeout)) // 等待RXNE位置1
            return 1;
        *(pData + i) = LL_I2C_ReceiveData8(hi2c->Instance);                     // 读取数据
    }

    return 0;
}

/**
 * @brief 使用硬件I2C阻塞方式，向内存写入数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] MemAddress 内存起始地址
 * @param[in] MemAddSize 内存地址宽度，8位或者16位
 *                       I2C_MEMADD_SIZE_8BIT
 *                       I2C_MEMADD_SIZE_16BIT 1
 * @param[in] pData 写入数据的缓冲区地址
 * @param[in] Size 待写入的数据长度
 * @param[in] Timeout 超时时间
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_mem_write(
    I2C_HandleTypeDef* hi2c,
    uint16_t SlaveAddr,
    uint16_t MemAddress,
    uint16_t MemAddSize,
    uint8_t* pData,
    uint16_t Size,
    uint32_t Timeout
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, Timeout)) // 等待busy位置0
        return 1;
    LL_I2C_GenerateStartCondition(hi2c->Instance);                          // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, Timeout))   // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));                 // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, Timeout)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance);     // 清除addr标志位

    if (MemAddress == I2C_MEMADD_SIZE_16BIT) { // 发送内存地址
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout))
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress >> 8)); // 地址高8位
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout))
        return 1;
    LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress)); // 地址低8位

    for (uint32_t i = 0; i < Size; i++) {                        // 逐字节发送
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout)) // 等待TxE位置1
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, *(pData + i));                    // 发送数据
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BTF, 1, Timeout)) // 等待BTF位置1
        return 1;
    LL_I2C_GenerateStopCondition(hi2c->Instance);                          // 生成stop信号

    return 0;
}

/**
 * @brief 使用硬件I2C阻塞方式，读取内存数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] MemAddress 内存起始地址
 * @param[in] MemAddSize 内存地址宽度，8位或者16位
 *                       I2C_MEMADD_SIZE_8BIT
 *                       I2C_MEMADD_SIZE_16BIT 1
 * @param[in] pData 读取数据的缓冲区地址
 * @param[in] Size 待读取的数据长度
 * @param[in] Timeout 超时时间
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_mem_read(
    I2C_HandleTypeDef* hi2c,
    uint16_t SlaveAddr,
    uint16_t MemAddress,
    uint16_t MemAddSize,
    uint8_t* pData,
    uint16_t Size,
    uint32_t Timeout
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, Timeout)) // 等待busy位置0
        return 1;
    LL_I2C_GenerateStartCondition(hi2c->Instance);                          // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, Timeout))   // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));                 // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, Timeout)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance);     // 清除addr标志位

    if (MemAddress == I2C_MEMADD_SIZE_16BIT) { // 发送内存地址
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout))
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress >> 8)); // 地址高8位
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, Timeout))
        return 1;
    LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress));          // 地址低8位

    LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_ACK);               // 置位ACK
    LL_I2C_GenerateStartCondition(hi2c->Instance);                        // 生成restart信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, Timeout)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1) | 1);             // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, Timeout)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance); // 清除addr标志位

    for (uint32_t i = 0; i < Size; i++) {  // 读取数据
        if (i == Size - 1) {               // 接收最后一个数据前，发送NACK和stop
            LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_NACK); // 发送NACK
            LL_I2C_GenerateStopCondition(hi2c->Instance);            // 生成stop信号
        }
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_RXNE, 1, Timeout)) // 等待RXNE位置1
            return 1;
        *(pData + i) = LL_I2C_ReceiveData8(hi2c->Instance);                     // 读取数据
    }

    return 0;
}

/**
 * @brief 使用硬件I2C，DMA方式发送数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] pData 待发送数据的地址
 * @param[in] Size 待发送数据的长度
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_transmit_dma(
    I2C_HandleTypeDef* hi2c, uint16_t SlaveAddr, uint8_t* pData, uint16_t Size
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, 10)) // 等待busy位置0
        return 1;

    // DMA配置
    LL_DMA_DisableStream(hi2c->dmatx, hi2c->dmatx_stream);
    LL_DMA_SetMemoryAddress(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t)pData);
    LL_DMA_SetPeriphAddress(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t) & (hi2c->Instance->DR));
    LL_DMA_SetDataLength(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t)Size);
    LL_DMA_EnableIT_TC(hi2c->dmatx, hi2c->dmatx_stream);
    LL_DMA_EnableStream(hi2c->dmatx, hi2c->dmatx_stream);
    LL_I2C_EnableDMAReq_TX(hi2c->Instance);

    LL_I2C_GenerateStartCondition(hi2c->Instance);                   // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, 10)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));            // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, 10)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance);                             // 清除addr标志位

    return 0;

    /* add the following code to DMA TC interruption. */
    // LL_I2C_DisableDMAReq_TX(i2c1_handle.Instance);
    // while (!LL_I2C_IsActiveFlag_BTF(i2c1_handle.Instance)) {}
    // LL_I2C_GenerateStopCondition(i2c1_handle.Instance);
}

/**
 * @brief 使用硬件I2C，DMA方式接收数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] pData 待接收数据的地址
 * @param[in] Size 待接收数据的长度
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_receive_dma(
    I2C_HandleTypeDef* hi2c, uint16_t SlaveAddr, uint8_t* pData, uint16_t Size
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, 10)) // 等待busy位置0
        return 1;

    // DMA配置
    LL_DMA_DisableStream(hi2c->dmarx, hi2c->dmarx_stream);
    LL_DMA_SetMemoryAddress(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t)pData);
    LL_DMA_SetPeriphAddress(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t) & (hi2c->Instance->DR));
    LL_DMA_SetDataLength(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t)Size);
    LL_DMA_EnableIT_TC(hi2c->dmarx, hi2c->dmarx_stream);
    LL_DMA_EnableStream(hi2c->dmarx, hi2c->dmarx_stream);
    LL_I2C_EnableDMAReq_RX(hi2c->Instance);
    LL_I2C_EnableLastDMA(hi2c->Instance);

    LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_ACK);          // 置位ACK
    LL_I2C_GenerateStartCondition(hi2c->Instance);                   // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, 10)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1) | 1);        // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, 10)) // 等待ADDR位置1
        return 1;
    if (Size == 1) { // 一个字节情况，需要手动NACK
        LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_NACK);
    }
    LL_I2C_ClearFlag_ADDR(hi2c->Instance); // 清除addr标志位

    return 0;

    /* add the following code to DMA TC interruption. */
    // LL_I2C_DisableDMAReq_RX(i2c1_handle.Instance);
    // LL_I2C_GenerateStopCondition(i2c1_handle.Instance);
}

/**
 * @brief 使用硬件I2C，DMA方式，写入内存数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] MemAddress 内存起始地址
 * @param[in] MemAddSize 内存地址宽度，8位或者16位
 *                       I2C_MEMADD_SIZE_8BIT
 *                       I2C_MEMADD_SIZE_16BIT 1
 * @param[in] pData 写入数据的缓冲区地址
 * @param[in] Size 待写入的数据长度
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_mem_write_dma(
    I2C_HandleTypeDef* hi2c,
    uint16_t SlaveAddr,
    uint16_t MemAddress,
    uint16_t MemAddSize,
    uint8_t* pData,
    uint16_t Size
)
{
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, 10)) // 等待busy位置0
        return 1;

    // DMA配置
    LL_DMA_DisableStream(hi2c->dmatx, hi2c->dmatx_stream);
    LL_DMA_SetMemoryAddress(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t)pData);
    LL_DMA_SetPeriphAddress(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t) & (hi2c->Instance->DR));
    LL_DMA_SetDataLength(hi2c->dmatx, hi2c->dmatx_stream, (uint32_t)Size);
    LL_DMA_EnableIT_TC(hi2c->dmatx, hi2c->dmatx_stream);
    LL_DMA_EnableStream(hi2c->dmatx, hi2c->dmatx_stream);

    LL_I2C_GenerateStartCondition(hi2c->Instance);                   // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, 10)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));            // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, 10)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance);                             // 清除addr标志位

    if (MemAddress == I2C_MEMADD_SIZE_16BIT) {                         // 发送内存地址
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, 10))
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress >> 8)); // 地址高8位
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, 10))
        return 1;
    LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress)); // 地址低8位
    LL_I2C_EnableDMAReq_TX(hi2c->Instance);

    return 0;
}

/**
 * @brief 使用硬件I2C，DMA方式，读取内存数据
 * @param[in] hi2c i2c_handler句柄, @struct I2C_HandleTypeDef
 * @param[in] SlaveAddr 从机地址
 * @param[in] MemAddress 内存起始地址
 * @param[in] MemAddSize 内存地址宽度，8位或者16位
 *                       I2C_MEMADD_SIZE_8BIT
 *                       I2C_MEMADD_SIZE_16BIT 1
 * @param[in] pData 读取数据的缓冲区地址
 * @param[in] Size 待读取的数据长度
 * @return 0: 成功
 *         1：等待超时或者出现错误
 */
uint8_t hal_i2c_mem_read_dma(
    I2C_HandleTypeDef* hi2c,
    uint16_t SlaveAddr,
    uint16_t MemAddress,
    uint16_t MemAddSize,
    uint8_t* pData,
    uint16_t Size
)
{

    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_BUSY, 0, 10)) // 等待busy位置0
        return 1;

    // DMA配置
    LL_DMA_DisableStream(hi2c->dmarx, hi2c->dmarx_stream);
    LL_DMA_SetMemoryAddress(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t)pData);
    LL_DMA_SetPeriphAddress(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t) & (hi2c->Instance->DR));
    LL_DMA_SetDataLength(hi2c->dmarx, hi2c->dmarx_stream, (uint32_t)Size);
    LL_DMA_EnableIT_TC(hi2c->dmarx, hi2c->dmarx_stream);
    LL_DMA_EnableStream(hi2c->dmarx, hi2c->dmarx_stream);
    LL_I2C_EnableLastDMA(hi2c->Instance);

    LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_ACK);
    LL_I2C_GenerateStartCondition(hi2c->Instance);                   // 生成start信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, 10)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1));            // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, 10)) // 等待ADDR位置1
        return 1;
    LL_I2C_ClearFlag_ADDR(hi2c->Instance);                             // 清除addr标志位

    if (MemAddress == I2C_MEMADD_SIZE_16BIT) {                         // 发送内存地址
        if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, 10))
            return 1;
        LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress >> 8)); // 地址高8位
    }
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_TXE, 1, 10))
        return 1;
    LL_I2C_TransmitData8(hi2c->Instance, (uint8_t)(MemAddress));     // 地址低8位

    LL_I2C_GenerateStartCondition(hi2c->Instance);                   // 生成restart信号
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_SB, 1, 10)) // 等待SB位置1
        return 1;

    LL_I2C_TransmitData8(hi2c->Instance, (SlaveAddr << 1) | 1);        // 发送slave地址
    if (I2C_WaitFlag(hi2c->Instance, LL_I2C_IsActiveFlag_ADDR, 1, 10)) // 等待ADDR位置1
        return 1;
    if (Size == 1) { // 一个字节情况，需要手动NACK
        LL_I2C_AcknowledgeNextData(hi2c->Instance, LL_I2C_NACK);
    }
    LL_I2C_ClearFlag_ADDR(hi2c->Instance); // 清除addr标志位
    LL_I2C_EnableDMAReq_RX(hi2c->Instance);

    return 0;
}
